home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_400 / 405_01 / Discussion < prev    next >
Internet Message Format  |  1993-07-17  |  9KB
  1. From coetmeur Mon Jul 19 14:08:43 1993
  2. To: ramanand@thor.ece.uc.EDU
  3. Subject: Re: flex++/bison++
  4. Content-Type: X-sun-attachment
  5. Content-Length: 8382
  6. X-Lines: 312
  7. Status: RO
  8.  
  9. ----------
  10. X-Sun-Data-Type: text
  11. X-Sun-Data-Description: text
  12. X-Sun-Data-Name: text
  13. X-Sun-Content-Lines: 114
  14.  
  15.  
  16. > From root Thu Jul 15 20:00:27 1993
  17. > >From ramanand@thor.ece.uc.EDU Thu Jul 15 20:00:27 1993
  18. > Date: 15 Jul 93 13:57:27-0400
  19. > From: John Holmes Sr <ramanand@thor.ece.uc.EDU>
  20. > Subject: flex++/bison++
  21. > To: coetmeur@icdc.fr
  22. > MIME-version: 1.0
  23. > Content-Type> : > text/plain> ; > charset=US-ASCII> 
  24. > Content-transfer-encoding: 7bit
  25. > 
  26. > Hello Alain,
  27. > 
  28. > I recently ported the flex++/bison++ software that you have put up on the
  29. > ftp server under comp.compilers. 
  30. > 
  31. > First of all I would like to complement you on a job well underakten. The
  32. > documentation is quite beneficial. 
  33. > 
  34. > However I have been having some problems with generating multiple parsers
  35. > in the same executable. It is quite possible that my understanding of the
  36. > full capabilities of the notions of class etc. are not quite up to the
  37. > mark. I would appreciate any help you can provide.
  38. > 
  39. > 
  40. > I have tried the following approach. If there is a better way, please let
  41. > me know.
  42. > 
  43. > 
  44. >     Prepare two bison++ files. Each of them declares a different class
  45. >     for the parser. Each of them declares its LEX_BODY as = 0 (i.e. a
  46. >     pure virtual function). Prepare two flex++ files. Each of them
  47. >     inherits the properties of the corresponding parser class and defines
  48. >     the lexical analyser functions. 
  49. > 
  50. >     So I now have two sets of header files. 
  51. > 
  52. >         a. parser1.h and lex1.h
  53. >         b. parser2.h and lex2.h
  54. > 
  55. >     
  56. > 
  57. > 
  58. > Each set of parser/lexical analyser individually compiles correctly
  59. > with the latest gnu c++  compiler. However, if I try to include both
  60. > the lexical header files (lex1.c and lex2.c) in the main file, I get syntax
  61. > errors. The reason is in the first two lines of these header files. They
  62. > are duplicated here below:
  63. > 
  64. >     #ifndef FLEX_HEADER_lex__h
  65. >     #define FLEX_HEADER_lex__h
  66. >     ...
  67. >     ...
  68. > 
  69. > 
  70. > Since both these files define the same symbol FLEX_HEADER_lex__h,
  71. > obviously the second time that I include the header file, it is ignored
  72. > by the preprocessor. 
  73. > 
  74. > Can you give me some solutions to this. Either I could somehow rename this
  75. > symbol , or you have  a better class hierarchy that I am unaware of
  76. > currently. 
  77. > 
  78.  
  79.  
  80.  
  81.     The way we can use multiple parser or scanner is by changing
  82.    the name of the scanner/parser with the directive %name. it is
  83.    ESSENTIAL. By default and for compatibility the name is set to 'lex'
  84.    and 'parse', but it should be changed to a different name for each
  85.    parser/scanner. Further, the scanner and parser must not have the
  86.    same name. the name given is used as the class name, and to build
  87.    many symbol names. So you should give a %name directive, before any
  88.    other in the flex++ and bison++ files. If all the header use the
  89.    symbol FLEX_HEADER_lex__h if shoul mean that they use the same
  90.    %name. If it is not the case, it is a very important bug. I was not
  91.    able to reproduce it with the data I have.
  92.  
  93.     The way to comunicate between the scanner and the parser is not
  94.    a trivial choic, and at our site we discussed much about it. The
  95.    problems are complex since the scanner use parser constant for token
  96.    ID, the parser use the scanner function as token furnisher, and so
  97.    on...
  98.  
  99.     The way that we used is to create a derived class from the
  100.    parser class, containing the scanner itself, and redefining the
  101.    token reader function of the parser to call the scanner function of
  102.    the scanner. It seems good for many reasons:
  103.  
  104.        - the compiler (ie parser+scanner) IS essentially a PARSER,
  105.          that USE a particular SCANNER to give tokens.
  106.  
  107.        - the intermediate function that give tokens from the
  108.          scanner to the parser is a good place to put trace, and
  109.          management function (line count...)
  110.  
  111.      The design was so important to explain to new users in our
  112.     site, that I decided to build a template of compiler that is a
  113.     base to modify. It should be present in misc++, but I send it as
  114.     attachment (4 files).
  115.  
  116.     I am concient that the documentation I have given is very
  117.     technical, and assume a deep knowledge of flex, bison, C/C++, and
  118.     some design experiences.
  119.  
  120.  
  121.     Please tell me was is the result of your new try, successful or not.
  122.  
  123.     Hoping I could help you, Best regard.
  124.  
  125.  
  126.     Alain Coetmeur
  127.  
  128.  
  129. ----------
  130. X-Sun-Data-Type: rdti-source-makefile
  131. X-Sun-Data-Name: makefile
  132. X-Sun-Content-Lines: 28
  133.  
  134.  
  135.  
  136. .SUFFIXES : .cc .y .l $(SUFFIXES)
  137.  
  138. .cc.o :
  139.     CC   -I$(CENTERCCLIBDIR)/incl -c  $*.cc
  140.  
  141. .y.cc :
  142.     bison++ -d  -o $*.cc -h $*.h  $*.y
  143. .l.cc :
  144.     flex++    -h$*.h -o$*.cc $*.l
  145. .y.h :
  146.     bison++ -d  -o $*.cc -h $*.h  $*.y
  147. .l.h :
  148.     flex++    -h$*.h -o$*.cc $*.l
  149.  
  150. all : compiler
  151.  
  152. MyCompiler.o : MyCompiler.cc MyParser.h MyScanner.h
  153.  
  154. MyParser.o : MyParser.cc MyParser.h
  155.  
  156. MyScanner.o : MyScanner.cc MyScanner.h MyParser.h
  157.  
  158.  
  159. compiler : MyCompiler.o MyParser.o MyScanner.o
  160.     CC  -o $@ MyCompiler.o MyParser.o MyScanner.o
  161.  
  162. ----------
  163. X-Sun-Data-Type: rdtq-source-l
  164. X-Sun-Data-Name: MyScanner.l
  165. X-Sun-Content-Lines: 42
  166.  
  167. /* %Z% %M% %Y% %Q% %I% %E% %U% (%F%) */
  168. /*
  169.  * Nom du Fichier :     |>nom_fichier<|
  170.  * Titre :         |>Titre<|
  171.  * Auteur:        |>auteur<|        
  172.  * Date de creation :    |>dateCreation<|
  173.  */
  174. /* Description :
  175.  *    Document de reference : |>doc<|
  176.  *    Objet : |>objet<|
  177.  *
  178.  */
  179. /* 
  180.  * historique :
  181.  * |>date<|    |>auteur<|    |>objet<|
  182.  */
  183. /* -------------- declaration section -------------- */
  184. %name MyScanner
  185.  
  186. %define LEX_PARAM YY_MyParser_STYPE *val,YY_MyParser_LTYPE *loc
  187. %define MEMBERS public: int theLine,theColumn;
  188. %define CONSTRUCTOR_INIT : theLine(1),theColumn(1)
  189. %header{ 
  190. #include "MyParser.h"
  191. %}
  192.  
  193. %{
  194. static char SccsId[]="%Z% %M% %Y% %Q% %I% %E% %U% (%F%)";
  195. %}
  196.  
  197. /* -------------- rules section -------------- */
  198. SPACES [ \t]+
  199. %%
  200. "\n"    {val->ctype='\n';
  201.          theLine++;theColumn=1;
  202.          return MyParser::EOL_TOKEN; }
  203. .    {
  204.          val->ctype=yytext[0];
  205.          theColumn++;
  206.          return MyParser::CHAR_TOKEN; }
  207. <<EOF>> { yyterminate();}
  208. %%
  209. ----------
  210. X-Sun-Data-Type: rdtq-source-y
  211. X-Sun-Data-Name: MyParser.y
  212. X-Sun-Content-Lines: 50
  213.  
  214. /* %Z% %M% %Y% %Q% %I% %E% %U% (%F%) */
  215. /*
  216.  * Nom du Fichier :     |>nom_fichier<|
  217.  * Titre :         |>Titre<|
  218.  * Auteur:        |>auteur<|
  219.  * Date de creation :    |>dateCreation<|
  220.  */
  221. /* Description :
  222.  *    Document de reference : |>doc<|
  223.  *    Objet : |>objet<|
  224.  *
  225.  */
  226. /*
  227.  * historique :
  228.  * |>date<|    |>auteur<|    |>objet<|
  229.  */
  230. /* -------------- declaration section -------------- */
  231.  
  232. %name MyParser
  233. %define LSP_NEEDED
  234. %define ERROR_BODY =0
  235. %define LEX_BODY =0
  236. %header{
  237. #include <stdio.h>
  238. %}
  239.  
  240. %union {
  241.     int itype;    /* for count */
  242.     char ctype;    /* for char */
  243.     }
  244. %token <ctype> EOL_TOKEN CHAR_TOKEN
  245. %type <itype> file line lines chars
  246. %start file
  247.  
  248. /* -------------- rules section -------------- */
  249. /* Sample parser. Does count Chars in a line, and lines in file */
  250. %%
  251. file    : lines
  252.     {printf("nlines=%d\n",$1); /* show line count */}
  253.     ;
  254. lines     : line {$$=1; /* first line of all */}
  255.     | lines line {$$=$1+1;    /* count one more line */}
  256.     ;
  257. line     : chars EOL_TOKEN {$$=$1;printf("nchars=%d\n",$1); /* show char count */}
  258.     ;
  259. chars    : CHAR_TOKEN { $$=1;/* first char of line */}
  260.     | chars CHAR_TOKEN {$$=$1+1; /* count one more char */}
  261.     ;
  262. %%
  263. /* -------------- body section -------------- */
  264. ----------
  265. X-Sun-Data-Type: rdtq-source-cc
  266. X-Sun-Data-Name: MyCompiler.cc
  267. X-Sun-Content-Lines: 52
  268.  
  269. static char SccsId[]="%Z% %M% %Y% %Q% %I% %E% %U% (%F%)";
  270. //
  271. // Nom du Fichier :     |>nom_fichier<|
  272. // Titre :         |>Titre<|
  273. // Auteur:        |>auteur<|        
  274. // Date de creation :    |>dateCreation<|
  275. //
  276. // Description :
  277. //    Document de reference : |>doc<|
  278. //    Objet : |>objet<|
  279. //
  280. //
  281. // 
  282. // historique :
  283. // |>date<|    |>auteur<|    |>objet<|
  284. //
  285. #include "MyScanner.h"
  286. #include "MyParser.h"
  287.  
  288. class MyCompiler : public MyParser
  289. {private:
  290.  MyScanner theScanner;
  291.  public:
  292.  virtual int yylex();
  293.  virtual void yyerror(char *m);
  294.  MyCompiler() 
  295.   {};
  296. };
  297.  
  298. int MyCompiler::yylex()
  299. {
  300.  yylloc.first_line=theScanner.theLine;
  301.  yylloc.first_column=theScanner.theColumn;
  302.  int token=theScanner.yylex(&yylval,&yylloc);
  303.  yylloc.last_line=theScanner.theLine;
  304.  yylloc.la